#include "ParseNodes.h"
#include "NodeVisitor.h"
using namespace std;

/* DEFINE ALL THE ACCEPT FUNCTIONS */
void RootNode::Accept(NodeVisitor *visitor) {
	if (visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if (visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void IfStatementNode::Accept(NodeVisitor *visitor) {
	if (visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if (visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void BinaryOperatorExpressionNode::Accept(NodeVisitor *visitor) {
	if (visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if (visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}

void CompilationUnitNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void PackageDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ImportDeclarationsNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ImportDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void SingleTypeImportDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void TypeImportOnDemandDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void TypeDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ModifiersNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ModifierNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void SuperNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfacesNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfaceTypeListNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassBodyNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassBodyDeclarationsNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassBodyDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassMemberDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void FieldDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void VariableDeclaratorNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void VariableInitializerNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MethodDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MethodHeaderNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MethodDeclaratorNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void FormalParameterListNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void FormalParameterNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MethodBodyNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ConstructorDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ConstructorDeclaratorNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ConstructorBodyNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfaceDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ExtendsInterfacesNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfaceBodyNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfaceMemberDeclarationsNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfaceMemberDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void AbstractMethodDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void BlockNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void BlockStatementsNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void BlockStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void LocalVariableDeclarationStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void LocalVariableDeclarationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void StatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void StatementNoShortIfNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void StatementWithoutTrailingSubstatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void EmptyStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ExpressionStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void StatementExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void IfThenStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void IfThenElseStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void IfThenElseStatementNoShortIfNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void WhileStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void WhileStatementNoShortIfNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ForStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ForStatementNoShortIfNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ForInitNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ForUpdateNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ReturnStatementNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void PrimaryNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void PrimaryNoNewArrayNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassInstanceCreationExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassInstanceCreationExpressionWithoutArgumentsNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ArgumentListNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ArrayCreationExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void DimExprNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void FieldAccessNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MethodInvocationNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MethodInvocationWithoutArgumentsNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ArrayAccessNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void AssignmentNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void LeftHandSideNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ConditionalOrExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ConditionalAndExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InclusiveOrExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ExclusiveOrExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void AndExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void EqualityExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void RelationalExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void AdditiveExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void MultiplicativeExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void UnaryExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void UnaryExpressionNotPlusMinusNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void PostfixExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void CastExpressionNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void InterfaceTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void TypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void PrimitiveTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void NumericTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void IntegralTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ReferenceTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ClassOrInterfaceTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ArrayTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void PrimitiveArrayTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void ObjectArrayTypeNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void NameNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void SimpleNameNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void QualifiedNameNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void LiteralNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}
void IntegerLiteralNode::Accept(NodeVisitor *visitor) { if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return; }
void BooleanLiteralNode::Accept(NodeVisitor *visitor) { if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return; }
void CharacterLiteralNode::Accept(NodeVisitor *visitor) { if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return; }
void StringLiteralNode::Accept(NodeVisitor *visitor) { 
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return; 
}
void NullLiteralNode::Accept(NodeVisitor *visitor) {
	if(visitor->traverseType & NodeVisitor::Pre) { visitor->current_traverse = NodeVisitor::Pre; CascadeAccept(visitor); }
	if(visitor->Break()) return;
	visitor->visit(this);
	if(visitor->Break()) return;
	if(visitor->traverseType & NodeVisitor::Post) { visitor->current_traverse = NodeVisitor::Post; CascadeAccept(visitor); }
}

/* Return the node type in string format (it's virtual) */
string IfStatementNode::Type() { return "IfStatement"; }
string BinaryOperatorExpressionNode::Type() { return "BinaryOperatorExpression"; }

string CompilationUnitNode::Type() { return "CompilationUnit"; }
string PackageDeclarationNode::Type() { return "PackageDeclaration"; }
string ImportDeclarationsNode::Type() { return "ImportDeclarations"; }
string ImportDeclarationNode::Type() { return "ImportDeclaration"; }
string SingleTypeImportDeclarationNode::Type() { return "SingleTypeImportDeclaration"; }
string TypeImportOnDemandDeclarationNode::Type() { return "TypeImportOnDemandDeclaration"; }
string TypeDeclarationNode::Type() { return "TypeDeclaration"; }
string ClassDeclarationNode::Type() { return "ClassDeclaration"; }
string ModifiersNode::Type() { return "Modifiers"; }
string ModifierNode::Type() { return "Modifier"; }
string SuperNode::Type() { return "Super"; }
string InterfacesNode::Type() { return "Interfaces"; }
string InterfaceTypeListNode::Type() { return "InterfaceTypeList"; }
string ClassBodyNode::Type() { return "ClassBody"; }
string ClassBodyDeclarationsNode::Type() { return "ClassBodyDeclarations"; }
string ClassBodyDeclarationNode::Type() { return "ClassBodyDeclaration"; }
string ClassMemberDeclarationNode::Type() { return "ClassMemberDeclaration"; }
string FieldDeclarationNode::Type() { return "FieldDeclaration"; }
string VariableDeclaratorNode::Type() { return "VariableDeclarator"; }
string VariableInitializerNode::Type() { return "VariableInitializer"; }
string MethodDeclarationNode::Type() { return "MethodDeclaration"; }
string MethodHeaderNode::Type() { return "MethodHeader"; }
string MethodDeclaratorNode::Type() { return "MethodDeclarator"; }
string FormalParameterListNode::Type() { return "FormalParameterList"; }
string FormalParameterNode::Type() { return "FormalParameter"; }
string MethodBodyNode::Type() { return "MethodBody"; }
string ConstructorDeclarationNode::Type() { return "ConstructorDeclaration"; }
string ConstructorDeclaratorNode::Type() { return "ConstructorDeclarator"; }
string ConstructorBodyNode::Type() { return "ConstructorBody"; }
string InterfaceDeclarationNode::Type() { return "InterfaceDeclaration"; }
string ExtendsInterfacesNode::Type() { return "ExtendsInterfaces"; }
string InterfaceBodyNode::Type() { return "InterfaceBody"; }
string InterfaceMemberDeclarationsNode::Type() { return "InterfaceMemberDeclarations"; }
string InterfaceMemberDeclarationNode::Type() { return "InterfaceMemberDeclaration"; }
string AbstractMethodDeclarationNode::Type() { return "AbstractMethodDeclaration"; }
string BlockNode::Type() { return "Block"; }
string BlockStatementsNode::Type() { return "BlockStatements"; }
string BlockStatementNode::Type() { return "BlockStatement"; }
string LocalVariableDeclarationStatementNode::Type() { return "LocalVariableDeclarationStatement"; }
string LocalVariableDeclarationNode::Type() { return "LocalVariableDeclaration"; }
string StatementNode::Type() { return "Statement"; }
string StatementNoShortIfNode::Type() { return "StatementNoShortIf"; }
string StatementWithoutTrailingSubstatementNode::Type() { return "StatementWithoutTrailingSubstatement"; }
string EmptyStatementNode::Type() { return "EmptyStatement"; }
string ExpressionStatementNode::Type() { return "ExpressionStatement"; }
string StatementExpressionNode::Type() { return "StatementExpression"; }
string IfThenStatementNode::Type() { return "IfThenStatement"; }
string IfThenElseStatementNode::Type() { return "IfThenElseStatement"; }
string IfThenElseStatementNoShortIfNode::Type() { return "IfThenElseStatementNoShortIf"; }
string WhileStatementNode::Type() { return "WhileStatement"; }
string WhileStatementNoShortIfNode::Type() { return "WhileStatementNoShortIf"; }
string ForStatementNode::Type() { return "ForStatement"; }
string ForStatementNoShortIfNode::Type() { return "ForStatementNoShortIf"; }
string ForInitNode::Type() { return "ForInit"; }
string ForUpdateNode::Type() { return "ForUpdate"; }
string ReturnStatementNode::Type() { return "ReturnStatement"; }
string PrimaryNode::Type() { return "Primary"; }
string PrimaryNoNewArrayNode::Type() { return "PrimaryNoNewArray"; }
string ClassInstanceCreationExpressionNode::Type() { return "ClassInstanceCreationExpression"; }
string ClassInstanceCreationExpressionWithoutArgumentsNode::Type() { return "ClassInstanceCreationExpressionWithoutArguments"; }
string ArgumentListNode::Type() { return "ArgumentList"; }
string ArrayCreationExpressionNode::Type() { return "ArrayCreationExpression"; }
string DimExprNode::Type() { return "DimExpr"; }
string FieldAccessNode::Type() { return "FieldAccess"; }
string MethodInvocationNode::Type() { return "MethodInvocation"; }
string MethodInvocationWithoutArgumentsNode::Type() { return "MethodInvocationWithoutArguments"; }
string ArrayAccessNode::Type() { return "ArrayAccess"; }
string ExpressionNode::Type() { return "Expression"; }
string AssignmentNode::Type() { return "Assignment"; }
string LeftHandSideNode::Type() { return "LeftHandSide"; }
string ConditionalOrExpressionNode::Type() { return "ConditionalOrExpression"; }
string ConditionalAndExpressionNode::Type() { return "ConditionalAndExpression"; }
string InclusiveOrExpressionNode::Type() { return "InclusiveOrExpression"; }
string ExclusiveOrExpressionNode::Type() { return "ExclusiveOrExpression"; }
string AndExpressionNode::Type() { return "AndExpression"; }
string EqualityExpressionNode::Type() { return "EqualityExpression"; }
string RelationalExpressionNode::Type() { return "RelationalExpression"; }
string AdditiveExpressionNode::Type() { return "AdditiveExpression"; }
string MultiplicativeExpressionNode::Type() { return "MultiplicativeExpression"; }
string UnaryExpressionNode::Type() { return "UnaryExpression"; }
string UnaryExpressionNotPlusMinusNode::Type() { return "UnaryExpressionNotPlusMinus"; }
string PostfixExpressionNode::Type() { return "PostfixExpression"; }
string CastExpressionNode::Type() { return "CastExpression"; }
string ClassTypeNode::Type() { return "ClassType"; }
string InterfaceTypeNode::Type() { return "InterfaceType"; }
string TypeNode::Type() { return "Type"; }
string PrimitiveTypeNode::Type() { return "PrimitiveType"; }
string NumericTypeNode::Type() { return "NumericType"; }
string IntegralTypeNode::Type() { return "IntegralType"; }
string ReferenceTypeNode::Type() { return "ReferenceType"; }
string ClassOrInterfaceTypeNode::Type() { return "ClassOrInterfaceType"; }
string ArrayTypeNode::Type() { return "ArrayType"; }
string PrimitiveArrayTypeNode::Type() { return "PrimitiveArrayType"; }
string ObjectArrayTypeNode::Type() { return "ObjectArrayType"; }
string NameNode::Type() { return "Name"; }
string SimpleNameNode::Type() { return "SimpleName"; }
string QualifiedNameNode::Type() { return "QualifiedName"; }
string LiteralNode::Type() { return "Literal"; }
string IntegerLiteralNode::Type() { return "IntegerLiteral"; }
string BooleanLiteralNode::Type() { return "BooleanLiteral"; }
string CharacterLiteralNode::Type() { return "CharacterLiteral"; }
string StringLiteralNode::Type() { return "StringLiteral"; }
string NullLiteralNode::Type() { return "NullLiteral"; }

bool IntegerLiteralNode::IsParent() { return false; }
bool BooleanLiteralNode::IsParent() { return false; }
bool CharacterLiteralNode::IsParent() { return false; }
bool StringLiteralNode::IsParent() { return false; }

static const map<string, ParseNode*> InitialiseTypeMapping() {
	map<string, ParseNode*> mapping;

	mapping["CompilationUnit"] = new CompilationUnitNode;
	mapping["PackageDeclaration"] = new PackageDeclarationNode;
	mapping["ImportDeclarations"] = new ImportDeclarationsNode;
	mapping["ImportDeclaration"] = new ImportDeclarationNode;
	mapping["SingleTypeImportDeclaration"] = new SingleTypeImportDeclarationNode;
	mapping["TypeImportOnDemandDeclaration"] = new TypeImportOnDemandDeclarationNode;
	mapping["TypeDeclaration"] = new TypeDeclarationNode;
	mapping["ClassDeclaration"] = new ClassDeclarationNode;
	mapping["Modifiers"] = new ModifiersNode;
	mapping["Modifier"] = new ModifierNode;
	mapping["Super"] = new SuperNode;
	mapping["Interfaces"] = new InterfacesNode;
	mapping["InterfaceTypeList"] = new InterfaceTypeListNode;
	mapping["ClassBody"] = new ClassBodyNode;
	mapping["ClassBodyDeclarations"] = new ClassBodyDeclarationsNode;
	mapping["ClassBodyDeclaration"] = new ClassBodyDeclarationNode;
	mapping["ClassMemberDeclaration"] = new ClassMemberDeclarationNode;
	mapping["FieldDeclaration"] = new FieldDeclarationNode;
	mapping["VariableDeclarator"] = new VariableDeclaratorNode;
	mapping["VariableInitializer"] = new VariableInitializerNode;
	mapping["MethodDeclaration"] = new MethodDeclarationNode;
	mapping["MethodHeader"] = new MethodHeaderNode;
	mapping["MethodDeclarator"] = new MethodDeclaratorNode;
	mapping["FormalParameterList"] = new FormalParameterListNode;
	mapping["FormalParameter"] = new FormalParameterNode;
	mapping["MethodBody"] = new MethodBodyNode;
	mapping["ConstructorDeclaration"] = new ConstructorDeclarationNode;
	mapping["ConstructorDeclarator"] = new ConstructorDeclaratorNode;
	mapping["ConstructorBody"] = new ConstructorBodyNode;
	mapping["InterfaceDeclaration"] = new InterfaceDeclarationNode;
	mapping["ExtendsInterfaces"] = new ExtendsInterfacesNode;
	mapping["InterfaceBody"] = new InterfaceBodyNode;
	mapping["InterfaceMemberDeclarations"] = new InterfaceMemberDeclarationsNode;
	mapping["InterfaceMemberDeclaration"] = new InterfaceMemberDeclarationNode;
	mapping["AbstractMethodDeclaration"] = new AbstractMethodDeclarationNode;
	mapping["Block"] = new BlockNode;
	mapping["BlockStatements"] = new BlockStatementsNode;
	mapping["BlockStatement"] = new BlockStatementNode;
	mapping["LocalVariableDeclarationStatement"] = new LocalVariableDeclarationStatementNode;
	mapping["LocalVariableDeclaration"] = new LocalVariableDeclarationNode;
	mapping["Statement"] = new StatementNode;
	mapping["StatementNoShortIf"] = new StatementNode;
	mapping["StatementWithoutTrailingSubstatement"] = new StatementNode;
	mapping["EmptyStatement"] = new StatementNode;
	mapping["ExpressionStatement"] = new StatementNode;
	mapping["StatementExpression"] = new StatementNode;
	mapping["IfThenStatement"] = new IfStatementNode;
	mapping["IfThenElseStatement"] = new IfStatementNode;
	mapping["IfThenElseStatementNoShortIf"] = new IfStatementNode;
	mapping["WhileStatement"] = new WhileStatementNode;
	mapping["WhileStatementNoShortIf"] = new WhileStatementNode;
	mapping["ForStatement"] = new ForStatementNode;
	mapping["ForStatementNoShortIf"] = new ForStatementNode;
	mapping["ForInit"] = new ForInitNode;
	mapping["ForUpdate"] = new ForUpdateNode;
	mapping["ReturnStatement"] = new ReturnStatementNode;
	mapping["Primary"] = new PrimaryNode;
	mapping["PrimaryNoNewArray"] = new PrimaryNoNewArrayNode;
	mapping["ClassInstanceCreationExpression"] = new ClassInstanceCreationExpressionNode;
	mapping["ClassInstanceCreationExpressionWithoutArguments"] = new ClassInstanceCreationExpressionWithoutArgumentsNode;
	mapping["ArgumentList"] = new ArgumentListNode;
	mapping["ArrayCreationExpression"] = new ArrayCreationExpressionNode;
	mapping["DimExpr"] = new DimExprNode;
	mapping["FieldAccess"] = new FieldAccessNode;
	mapping["MethodInvocation"] = new MethodInvocationNode;
	mapping["MethodInvocationWithoutArguments"] = new MethodInvocationWithoutArgumentsNode;
	mapping["ArrayAccess"] = new ArrayAccessNode;
	mapping["Expression"] = new ExpressionNode;
	mapping["Assignment"] = new AssignmentNode;
	mapping["LeftHandSide"] = new LeftHandSideNode;
	mapping["ConditionalOrExpression"] = new ConditionalOrExpressionNode;
	mapping["ConditionalAndExpression"] = new ConditionalAndExpressionNode;
	mapping["InclusiveOrExpression"] = new InclusiveOrExpressionNode;
	mapping["ExclusiveOrExpression"] = new ExclusiveOrExpressionNode;
	mapping["AndExpression"] = new AndExpressionNode;
	mapping["EqualityExpression"] = new EqualityExpressionNode;
	mapping["RelationalExpression"] = new RelationalExpressionNode;
	mapping["AdditiveExpression"] = new AdditiveExpressionNode;
	mapping["MultiplicativeExpression"] = new MultiplicativeExpressionNode;
	mapping["UnaryExpression"] = new UnaryExpressionNode;
	mapping["UnaryExpressionNotPlusMinus"] = new UnaryExpressionNotPlusMinusNode;
	mapping["PostfixExpression"] = new PostfixExpressionNode;
	mapping["CastExpression"] = new CastExpressionNode;
	mapping["ClassType"] = new ClassTypeNode;
	mapping["InterfaceType"] = new InterfaceTypeNode;
	mapping["Type"] = new TypeNode;
	mapping["PrimitiveType"] = new PrimitiveTypeNode;
	mapping["NumericType"] = new NumericTypeNode;
	mapping["IntegralType"] = new IntegralTypeNode;
	mapping["ReferenceType"] = new ReferenceTypeNode;
	mapping["ClassOrInterfaceType"] = new TypeNode;
	mapping["ArrayType"] = new ArrayTypeNode;
	mapping["PrimitiveArrayType"] = new PrimitiveArrayTypeNode;
	mapping["ObjectArrayType"] = new ObjectArrayTypeNode;
	mapping["Name"] = new NameNode;
	mapping["SimpleName"] = new SimpleNameNode;
	mapping["QualifiedName"] = new QualifiedNameNode;
	mapping["Literal"] = new LiteralNode;
	mapping["IntegerLiteral"] = new IntegerLiteralNode;
	mapping["BooleanLiteral"] = new BooleanLiteralNode;
	mapping["CharacterLiteral"] = new CharacterLiteralNode;
	mapping["StringLiteral"] = new StringLiteralNode;
	mapping["NullLiteral"] = new NullLiteralNode;
	return mapping;
}

const map<string, ParseNode*> ParseNode::_typeMapping = InitialiseTypeMapping();
